package com.finalterm.product.service;

import com.finalterm.product.config.ProductConfigProperties;
import com.finalterm.product.vo.ProductVO;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 商品缓存服务
 * 提供默认商品数据，用于服务降级时返回
 * 支持动态缓存时间配置
 */
@Slf4j
@Service
@RefreshScope
@RequiredArgsConstructor
public class ProductCacheService {

    private final ProductConfigProperties productConfig;
    
    /**
     * 默认商品缓存
     */
    private final Map<Long, ProductVO> defaultProductCache = new ConcurrentHashMap<>();

    /**
     * 商品详情缓存（带时间戳）
     */
    private final Map<Long, CacheItem> productDetailCache = new ConcurrentHashMap<>();

    /**
     * 缓存项
     */
    private static class CacheItem {
        private final ProductVO product;
        private final long timestamp;

        public CacheItem(ProductVO product) {
            this.product = product;
            this.timestamp = System.currentTimeMillis();
        }

        public ProductVO getProduct() {
            return product;
        }

        public boolean isExpired(int cacheTimeSeconds) {
            return System.currentTimeMillis() - timestamp > cacheTimeSeconds * 1000L;
        }

        public long getAge() {
            return System.currentTimeMillis() - timestamp;
        }
    }
    
    /**
     * 初始化默认商品缓存数据
     */
    @PostConstruct
    public void initDefaultProducts() {
        initDefaultProductsData();
        log.info("商品缓存服务初始化完成，当前缓存时间配置: {}秒", productConfig.getCache().getTime());
    }
    
    /**
     * 获取缓存的商品详情（支持动态缓存时间）
     */
    public ProductVO getCachedProductDetail(Long productId) {
        CacheItem cacheItem = productDetailCache.get(productId);
        Integer cacheTime = productConfig.getCache().getTime();

        if (cacheItem != null && !cacheItem.isExpired(cacheTime)) {
            log.info("返回缓存的商品详情，productId: {}, 缓存年龄: {}ms, 缓存时间配置: {}秒",
                    productId, cacheItem.getAge(), cacheTime);
            return cacheItem.getProduct();
        }

        if (cacheItem != null) {
            log.info("商品缓存已过期，productId: {}, 缓存年龄: {}ms, 缓存时间配置: {}秒",
                    productId, cacheItem.getAge(), cacheTime);
            productDetailCache.remove(productId);
        }

        return null;
    }

    /**
     * 缓存商品详情
     */
    public void cacheProductDetail(Long productId, ProductVO productVO) {
        productDetailCache.put(productId, new CacheItem(productVO));
        log.info("缓存商品详情，productId: {}, 当前缓存时间配置: {}秒",
                productId, productConfig.getCache().getTime());
    }

    /**
     * 获取默认商品信息
     */
    public ProductVO getDefaultProduct(Long productId) {
        ProductVO defaultProduct = defaultProductCache.get(productId);
        if (defaultProduct != null) {
            log.info("返回缓存的默认商品信息，productId: {}", productId);
            return defaultProduct;
        }

        // 如果缓存中没有，返回通用默认商品
        return createGenericDefaultProduct(productId);
    }
    
    /**
     * 创建通用默认商品
     */
    private ProductVO createGenericDefaultProduct(Long productId) {
        ProductVO defaultProduct = new ProductVO();
        defaultProduct.setId(productId);
        defaultProduct.setName("商品暂时无法获取");
        defaultProduct.setDescription("系统繁忙，商品信息暂时无法获取，请稍后重试");
        defaultProduct.setPrice(new BigDecimal("0.00"));
        defaultProduct.setStock(0);
        defaultProduct.setCategory("默认分类");
        defaultProduct.setImageUrl("/images/default-product.jpg");
        defaultProduct.setStatus(1);
        defaultProduct.setCreateTime(LocalDateTime.now());
        defaultProduct.setUpdateTime(LocalDateTime.now());
        
        log.warn("返回通用默认商品信息，productId: {}", productId);
        return defaultProduct;
    }
    
    /**
     * 初始化一些常用商品的默认数据
     */
    private void initDefaultProductsData() {
        // 商品1：手机
        ProductVO phone = new ProductVO();
        phone.setId(1L);
        phone.setName("智能手机（默认信息）");
        phone.setDescription("系统繁忙，显示缓存的商品信息");
        phone.setPrice(new BigDecimal("2999.00"));
        phone.setStock(0);
        phone.setCategory("电子产品");
        phone.setImageUrl("/images/default-phone.jpg");
        phone.setStatus(1);
        phone.setCreateTime(LocalDateTime.now());
        phone.setUpdateTime(LocalDateTime.now());
        defaultProductCache.put(1L, phone);
        
        // 商品2：笔记本电脑
        ProductVO laptop = new ProductVO();
        laptop.setId(2L);
        laptop.setName("笔记本电脑（默认信息）");
        laptop.setDescription("系统繁忙，显示缓存的商品信息");
        laptop.setPrice(new BigDecimal("5999.00"));
        laptop.setStock(0);
        laptop.setCategory("电子产品");
        laptop.setImageUrl("/images/default-laptop.jpg");
        laptop.setStatus(1);
        laptop.setCreateTime(LocalDateTime.now());
        laptop.setUpdateTime(LocalDateTime.now());
        defaultProductCache.put(2L, laptop);
        
        // 商品3：图书
        ProductVO book = new ProductVO();
        book.setId(3L);
        book.setName("技术图书（默认信息）");
        book.setDescription("系统繁忙，显示缓存的商品信息");
        book.setPrice(new BigDecimal("89.00"));
        book.setStock(0);
        book.setCategory("图书");
        book.setImageUrl("/images/default-book.jpg");
        book.setStatus(1);
        book.setCreateTime(LocalDateTime.now());
        book.setUpdateTime(LocalDateTime.now());
        defaultProductCache.put(3L, book);
        
        log.info("默认商品缓存初始化完成，缓存商品数量: {}", defaultProductCache.size());
    }
    
    /**
     * 添加或更新默认商品缓存
     */
    public void putDefaultProduct(Long productId, ProductVO productVO) {
        defaultProductCache.put(productId, productVO);
        log.info("更新默认商品缓存，productId: {}", productId);
    }
    
    /**
     * 清除指定商品的默认缓存
     */
    public void removeDefaultProduct(Long productId) {
        defaultProductCache.remove(productId);
        log.info("清除默认商品缓存，productId: {}", productId);
    }
    
    /**
     * 清除所有默认缓存
     */
    public void clearAllDefaultProducts() {
        defaultProductCache.clear();
        log.info("清除所有默认商品缓存");
    }
    
    /**
     * 获取缓存大小
     */
    public int getCacheSize() {
        return defaultProductCache.size();
    }

    /**
     * 获取商品详情缓存大小
     */
    public int getDetailCacheSize() {
        return productDetailCache.size();
    }

    /**
     * 清理过期的商品详情缓存
     */
    public void cleanExpiredCache() {
        Integer cacheTime = productConfig.getCache().getTime();
        int beforeSize = productDetailCache.size();

        productDetailCache.entrySet().removeIf(entry -> {
            boolean expired = entry.getValue().isExpired(cacheTime);
            if (expired) {
                log.debug("清理过期缓存，productId: {}, 缓存年龄: {}ms",
                        entry.getKey(), entry.getValue().getAge());
            }
            return expired;
        });

        int afterSize = productDetailCache.size();
        if (beforeSize != afterSize) {
            log.info("清理过期缓存完成，清理前: {}, 清理后: {}, 清理数量: {}",
                    beforeSize, afterSize, beforeSize - afterSize);
        }
    }

    /**
     * 获取当前缓存时间配置
     */
    public Integer getCurrentCacheTime() {
        return productConfig.getCache().getTime();
    }

    /**
     * 获取缓存统计信息
     */
    public String getCacheStats() {
        return String.format("默认缓存: %d, 详情缓存: %d, 缓存时间: %d秒",
                defaultProductCache.size(),
                productDetailCache.size(),
                productConfig.getCache().getTime());
    }
}
